import { request } from '@/utils/request'

// 基础配置
const BATTLE_URL = '/battle-api/battle/v1'
const RANK_URL = '/battle-api/rank/v1'
const AI_URL = '/battle-api/ai/v1'

/**
 * 对战管理接口
 */
export const BattleAPI = {
  // 初始化比赛
  initMatch: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/initMatch`,
      method: 'POST',
      data: {
        matchId: data.matchId,                    // 比赛ID
        name: data.name,                          // 比赛名称
        startTime: data.startTime,                // 开始时间
        endTime: data.endTime,                    // 结束时间
        desc: data.desc,                          // 比赛描述
        createUserID: data.createUserID,          // 创建用户ID
        sponsor: data.sponsor,                    // 赞助商
        status: data.status,                      // 状态
        matchModel: data.matchModel,              // 比赛模式
        matchModelId: data.matchModelId,          // 比赛模式ID
        pageNum: data.pageNum || 0,               // 页码
        pageSize: data.pageSize || 10             // 每页大小
      }
    })
  },

  // 初始化赛程
  initSchdule: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/initSchdule`,
      method: 'POST',
      data: {
        matchId: data.matchId,                    // 比赛ID
        name: data.name,                          // 比赛名称
        startTime: data.startTime,                // 开始时间
        endTime: data.endTime,                    // 结束时间
        desc: data.desc,                          // 比赛描述
        createUserID: data.createUserID,          // 创建用户ID
        sponsor: data.sponsor,                    // 赞助商
        status: data.status,                      // 状态
        matchModel: data.matchModel,              // 比赛模式
        matchModelId: data.matchModelId,          // 比赛模式ID
        pageNum: data.pageNum || 0,               // 页码
        pageSize: data.pageSize || 10             // 每页大小
      }
    })
  },

  // 创建赛程
  createSchedule: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/createSchedule`,
      method: 'POST',
      data: {
        matchId: data.matchId                     // 比赛ID
      }
    })
  },

  // 根据模式创建房间
  createRoomByModel: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/createRoomByModel`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId,  // 比赛模式ID
        matchScheduleId: data.matchScheduleId,                    // 赛程ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 手动创建房间
  createRoomByManually: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/createRoomByManually`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        roomNum: data.roomNum,                            // 房间数量
        roomType: data.roomType,                          // 房间类型
        roomTypeN: data.roomTypeN,                        // 房间类型N
        roomTypeM: data.roomTypeM,                        // 房间类型M
        roomStartType: data.roomStartType,                // 房间开始类型
        roomJoinModel: data.roomJoinModel,                // 房间加入模式
        roomLimitModel: data.roomLimitModel,              // 房间限制模式
        matchWinModel: data.matchWinModel,                // 比赛获胜模式
        roomRuleList: data.roomRuleList                  // 房间规则列表
      }
    })
  },

  // 创建房间座位
  createRoomSeats: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/createRoomSeats`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId,  // 比赛模式ID
        matchRoomId: data.matchRoomId,                    // 房间ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 加入房间
  joinRoom: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/joinRoom`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        name: data.name,                                  // 房间名称
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 查找创建加入房间
  findCreateJoinRoom: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/findCreateJoinRoom`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 更新房间状态
  updateRoomStatus: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/updateRoomStatus`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        event: data.event                                 // 事件类型
      }
    })
  },

  // 加入房间座位
  joinRoomSeat: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/joinRoomSeat`,
      method: 'POST',
      data: {
        matchRoomSeatId: data.matchRoomSeatId,            // 座位ID
        event: data.event                                 // 事件类型
      }
    })
  },

  // 更新房间座位状态
  updateRoomSeatStatus: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/updateRoomSeatStatus`,
      method: 'POST',
      data: {
        matchRoomSeatId: data.matchRoomSeatId,            // 座位ID
        event: data.event                                 // 事件类型
      }
    })
  },

  // 更新房间结果
  updateRoomResult: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/updateRoomResult`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchRoomSeatId: data.matchRoomSeatId,            // 座位ID
        matchRoomRuleId: data.matchRoomRuleId,            // 房间规则ID
        result: data.result,                              // 结果分数
        time: data.time,                                  // 用时(秒)
        status: data.status,                              // 状态
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        delFlag: data.delFlag || 0                        // 删除标志
      }
    })
  },

  // 计算房间结果
  calcRoomResults: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/calcRoomResults`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId                     // 房间ID
      }
    })
  },

  // 生成魔方打乱公式
  cubeGenerateScramble: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/cubeGenerateScramble`,
      method: 'POST',
      data: data || {}
    })
  },

  // 赛程报名
  regSchedule: (data) => {
    return request({
      url: `${BATTLE_URL}/battle/regSchedule`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,            // 要报名的赛程ID（必填）
        appId: data.appId,                                // 应用ID（必填）
        channel: data.channel,                            // 渠道ID（必填）
        pageSize: data.pageSize || 20,                    // 分页大小，默认20
        pageNum: data.pageNum || 0                        // 页码，默认0
      }
    })
  }
}

/**
 * 排行榜管理接口
 */
export const RankingAPI = {
  // 创建竞技场
  createArena: (data) => {
    return request({
      url: `${RANK_URL}/arena/create`,
      method: 'POST',
      data: {
        arenaName: data.arenaName,                        // 竞技场名称
        regionType: data.regionType,                      // 地区类型
        arenaType: data.arenaType,                        // 竞技场类型
        password: data.password                           // 密码(可选)
      }
    })
  },

  // 查询多个竞技场
  findManyArena: (data) => {
    return request({
      url: `${RANK_URL}/arena/findMany`,
      method: 'POST',
      data: {
        arenaId: data.arenaId,                            // 竞技场ID
        arenaName: data.arenaName,                        // 竞技场名称
        regionType: data.regionType,                      // 地区类型
        arenaType: data.arenaType,                        // 竞技场类型
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 查询单个竞技场
  findOneArena: (data) => {
    return request({
      url: `${RANK_URL}/arena/findOne`,
      method: 'POST',
      data: {
        arenaId: data.arenaId                             // 竞技场ID
      }
    })
  },

  // 加入竞技场
  joinArena: (data) => {
    return request({
      url: `${RANK_URL}/arena/join`,
      method: 'POST',
      data: {
        arenaId: data.arenaId                             // 竞技场ID
      }
    })
  },

  // 离开竞技场
  leaveArena: (data) => {
    return request({
      url: `${RANK_URL}/arena/leave`,
      method: 'POST',
      data: {
        arenaId: data.arenaId                             // 竞技场ID
      }
    })
  },

  // 获取已加入竞技场列表
  joinedListArena: (data) => {
    return request({
      url: `${RANK_URL}/arena/joinedList`,
      method: 'POST',
      data: data || {}
    })
  },

  // 地理位置逆解析
  locationReGeo: (data) => {
    return request({
      url: `${RANK_URL}/arena/location/reGeo`,
      method: 'POST',
      data: {
        longitude: data.longitude,                        // 经度
        latitude: data.latitude                           // 纬度
      }
    })
  },

  // 获取当前位置
  locationGet: (data) => {
    return request({
      url: `${RANK_URL}/arena/location/get`,
      method: 'POST',
      data: data || {}
    })
  },

  // 更新位置信息
  locationUpdate: (data) => {
    return request({
      url: `${RANK_URL}/arena/location/update`,
      method: 'POST',
      data: {
        longitude: data.longitude,                        // 经度
        latitude: data.latitude,                          // 纬度
        address: data.address                             // 地址
      }
    })
  },

  // 获取我的排名
  myRanking: (data) => {
    return request({
      url: `${RANK_URL}/arena/myRanking`,
      method: 'POST',
      data: {
        session: data.session,                            // 赛季
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        arenaId: data.arenaId,                            // 竞技场ID(可选)
        provinceAdCode: data.provinceAdCode,              // 省份行政码(可选)
        cityCode: data.cityCode,                          // 城市码(可选)
        adCode: data.adCode,                              // 城市行政区码(可选)
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 获取排行榜
  rankingList: (data) => {
    return request({
      url: `${RANK_URL}/arena/rankingList`,
      method: 'POST',
      data: {
        session: data.session,                            // 赛季
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        arenaId: data.arenaId,                            // 竞技场ID(可选)
        provinceAdCode: data.provinceAdCode,              // 省份行政码(可选)
        cityCode: data.cityCode,                          // 城市码(可选)
        adCode: data.adCode,                              // 城市行政区码(可选)
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  }
}

/**
 * 比赛管理接口
 */
export const MatchAPI = {
  // 创建比赛
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/match/create`,
      method: 'POST',
      data: {
        matchId: data.matchId,                            // 比赛ID
        name: data.name,                                  // 比赛名称
        startTime: data.startTime,                        // 开始时间
        endTime: data.endTime,                            // 结束时间
        desc: data.desc,                                  // 比赛描述
        createUserID: data.createUserID,                  // 创建用户ID
        sponsor: data.sponsor,                            // 赞助商
        status: data.status,                              // 状态
        matchModel: data.matchModel,                      // 比赛模式
        matchModelId: data.matchModelId,                  // 比赛模式ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 编辑比赛
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/match/edit`,
      method: 'POST',
      data: {
        matchId: data.matchId,                            // 比赛ID
        name: data.name,                                  // 比赛名称
        startTime: data.startTime,                        // 开始时间
        endTime: data.endTime,                            // 结束时间
        desc: data.desc,                                  // 比赛描述
        createUserID: data.createUserID,                  // 创建用户ID
        sponsor: data.sponsor,                            // 赞助商
        status: data.status,                              // 状态
        matchModel: data.matchModel,                      // 比赛模式
        matchModelId: data.matchModelId,                  // 比赛模式ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 删除比赛
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/match/remove`,
      method: 'POST',
      data: {
        matchId: data.matchId                             // 比赛ID
      }
    })
  },

  // 分页查询比赛
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/match/page`,
      method: 'POST',
      data: {
        matchId: data.matchId,                            // 比赛ID
        name: data.name,                                  // 比赛名称
        startTime: data.startTime,                        // 开始时间
        endTime: data.endTime,                            // 结束时间
        desc: data.desc,                                  // 比赛描述
        createUserID: data.createUserID,                  // 创建用户ID
        sponsor: data.sponsor,                            // 赞助商
        status: data.status,                              // 状态
        matchModel: data.matchModel,                      // 比赛模式
        matchModelId: data.matchModelId,                  // 比赛模式ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 赛事S2S-TOKEN分页查询
  s2sTokenPage(data) {
    return request({
      url: `${BATTLE_URL}/match/s2s/token/page`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,               // 页码
        pageSize: data.pageSize || 10             // 每页条数
      }
    })
  },
  

  // 赛程分页查询
  schedulePage(data) {
    return request({
      url: `${BATTLE_URL}/schedule/page`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        matchId: data.matchId,                    // 赛事ID
        name: data.name,                          // 赛程名称
        startTime: data.startTime,                        // 开始时间
        endTime: data.endTime,                            // 结束时间
        desc: data.desc,                                  // 赛程描述
        createUserID: data.createUserID,                  // 创建用户ID
        sponsor: data.sponsor,                            // 赞助商
        status: data.status,                              // 状态
        matchModel: data.matchModel,                      // 比赛模式
        matchModelId: data.matchModelId,                  // 比赛模式ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  getRank(data) {
    return request({
      url: `${BATTLE_URL}/match/rank/get`,
      method: 'POST',
      data: {
        scheduleId: data.scheduleId,              // 赛程ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页条数
      }
    })
  },

  listByUser(data) {
    return request({
      url: `${BATTLE_URL}/ai/review/list/user`,
      method: 'POST',
      data: {
        userId: data.userId,                      // 用户ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页条数
      }
    })
  },

  myCreated(data) {
    return request({
      url: `${BATTLE_URL}/match_room/my_created`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  myJoined(data) {
    return request({
      url: `${BATTLE_URL}/match_room/my_joined`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  list(data) {
    return request({
      url: `${BATTLE_URL}/match_room/user/list`,
      method: 'POST',
      data: {
        roomId: data.roomId,                      // 房间ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  records(data) {
    return request({
      url: `${BATTLE_URL}/match_room/records`,
      method: 'POST',
      data: {
        roomId: data.roomId,                      // 房间ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  page(data) {
    return request({
      url: `${BATTLE_URL}/match/page`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 赛事名称
        matchId: data.matchId,                            // 比赛ID
        startTime: data.startTime,                        // 开始时间
        endTime: data.endTime,                            // 结束时间
        desc: data.desc,                                  // 比赛描述
        createUserID: data.createUserID,                  // 创建用户ID
        sponsor: data.sponsor,                            // 赞助商
        status: data.status,                              // 状态
        matchModel: data.matchModel,                      // 比赛模式
        matchModelId: data.matchModelId,                  // 比赛模式ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  getByMatch(data) {
    return request({
      url: `${BATTLE_URL}/match/schedule/list/match`,
      method: 'POST',
      data: {
        matchId: data.matchId,                    // 赛事ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页条数
      }
    })
  },

  // 赛事日志分页查询
  logPage(data) {
    return request({
      url: `${BATTLE_URL}/match/log/page`,
      method: 'POST',
      data: {
        matchId: data.matchId,
        pageNum: data.pageNum || 0,
        pageSize: data.pageSize || 10,
        ...data
      }
    })
  }
}

/**
 * AI评审管理接口
 */
export const AiReviewAPI = {
  // 获取AI评审
  getReviews: (data) => {
    return request({
      url: `${AI_URL}/getReviews`,
      method: 'POST',
      data: {
        durationFrom: data.durationFrom,                  // 开始时间(秒)
        durationTo: data.durationTo                       // 结束时间(秒)
      }
    })
  },

  // 查询评审详情
  findReview: (data) => {
    return request({
      url: `${AI_URL}/findReview`,
      method: 'POST',
      data: {
        reviewId: data.reviewId                           // 评审ID
      }
    })
  },

  page(data) {
    return request({
      url: `${AI_URL}/review/page`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,
        pageSize: data.pageSize || 10,
        ...data
      }
    })
  },

  listByUser(data) {
    return request({
      url: `${AI_URL}/review/list/user`,
      method: 'POST',
      data: {
        userId: data.userId,                      // 用户ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页条数
      }
    })
  }
}

/**
 * 房间管理接口
 */
export const MatchRoomAPI = {
  // 创建房间
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/room/create`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        name: data.name,                                  // 房间名称
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 编辑房间
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/room/edit`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        name: data.name,                                  // 房间名称
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  // 删除房间
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/room/remove`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId                     // 房间ID
      }
    })
  },

  // 分页查询房间
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/room/page`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        name: data.name,                                  // 房间名称
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  myCreated(data) {
    return request({
      url: `${BATTLE_URL}/match_room/my_created`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  myJoined(data) {
    return request({
      url: `${BATTLE_URL}/match_room/my_joined`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  list(data) {
    return request({
      url: `${BATTLE_URL}/match_room/user/list`,
      method: 'POST',
      data: {
        roomId: data.roomId,                      // 房间ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  records(data) {
    return request({
      url: `${BATTLE_URL}/match_room/records`,
      method: 'POST',
      data: {
        roomId: data.roomId,                      // 房间ID
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10,                    // 每页条数
        name: data.name,                          // 房间名称
        matchId: data.matchId,                    // 赛事ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchTime: data.matchTime,                        // 比赛时间
        owner: data.owner,                                // 房主
        event: data.event,                                // 事件
        status: data.status,                              // 状态
        winModel: data.winModel,                          // 获胜模式
        startType: data.startType,                        // 开始类型
        seatList: data.seatList,                          // 座位列表
        createTime: data.createTime,                      // 创建时间
        updateTime: data.updateTime,                      // 更新时间
        pageNum: data.pageNum || 0,                       // 页码
        pageSize: data.pageSize || 10                     // 每页大小
      }
    })
  },

  logPage(data) {
    return request({
      url: `${BATTLE_URL}/match_room/log/page`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,
        pageSize: data.pageSize || 10,
        ...data
      }
    })
  }
}

/**
 * 比赛模式管理接口
 */
export const MatchModelAPI = {
  // 创建赛事模型
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchModel/create`,
      method: 'POST',
      data: {
        matchId: data.matchId,                              // 赛事ID（必填）
        matchModelName: data.matchModelName,                // 赛事模型名称（必填）
        matchScheduleModelId: data.matchScheduleModelId,    // 赛程模型ID（必填）
        nameTemplate: data.nameTemplate,                    // 名称模板（可选）
        matchScheduleCreateType: data.matchScheduleCreateType, // 赛程创建类型（可选）
        triggerType: data.triggerType,                      // 触发类型（可选）
        nextTriggerTime: data.nextTriggerTime,              // 下次触发时间（时间戳，可选）
        matchStartTime: data.matchStartTime,                // 比赛开始时间（时间戳，可选）
        matchEndTime: data.matchEndTime,                    // 比赛结束时间（时间戳，可选）
        pageSize: data.pageSize,                            // 分页大小（继承自PageDTO，可选）
        pageNum: data.pageNum                               // 页码（继承自PageDTO，可选）
      }
    })
  },

  // 编辑赛事模型
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchModel/edit`,
      method: 'POST',
      data: {
        matchModelId: data.matchModelId,                    // 赛事模型ID（必填，用于标识要修改的记录）
        matchId: data.matchId,                              // 赛事ID（可选）
        matchModelName: data.matchModelName,                // 赛事模型名称（可选）
        matchScheduleModelId: data.matchScheduleModelId,    // 赛程模型ID（可选）
        nameTemplate: data.nameTemplate,                    // 名称模板（可选）
        matchScheduleCreateType: data.matchScheduleCreateType, // 赛程创建类型（可选）
        triggerType: data.triggerType,                      // 触发类型（可选）
        nextTriggerTime: data.nextTriggerTime,              // 下次触发时间（时间戳，可选）
        matchStartTime: data.matchStartTime,                // 比赛开始时间（时间戳，可选）
        matchEndTime: data.matchEndTime                     // 比赛结束时间（时间戳，可选）
      }
    })
  },

  // 删除赛事模型
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchModel/remove`,
      method: 'POST',
      data: {
        matchModelId: data.matchModelId                     // 赛事模型ID（必填）
      }
    })
  },

  // 分页查询赛事模型
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchModel/page`,
      method: 'POST',
      data: {
        matchModelId: data.matchModelId,                    // 赛事模型ID（查询条件，可选）
        matchId: data.matchId,                              // 赛事ID（查询条件，可选）
        matchModelName: data.matchModelName,                // 赛事模型名称（查询条件，可选）
        matchScheduleModelId: data.matchScheduleModelId,    // 赛程模型ID（查询条件，可选）
        triggerType: data.triggerType,                      // 触发类型（查询条件，可选）
        pageSize: data.pageSize || 20,                      // 分页大小（默认20）
        pageNum: data.pageNum || 0                          // 页码（默认0）
      }
    })
  },

  // 获取所有比赛模式列表 (使用page接口获取所有数据)
  list: (data) => {
    return request({
      url: `${BATTLE_URL}/matchModel/page`,
      method: 'POST',
      data: {
        pageNum: data.pageNum || 0,                         // 页码
        pageSize: data.pageSize || 100,                     // 每页大小
        delFlag: data.delFlag || 0                          // 删除标志，0表示未删除
      }
    })
  },

  // 根据ID获取比赛模式详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchModel/get`,
      method: 'POST',
      data: {
        matchModelId: data.matchModelId                     // 比赛模式ID
      }
    })
  }
}

/**
 * 赛程管理接口
 */
export const MatchScheduleAPI = {
  // 创建赛程
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/schedule/create`,
      method: 'POST',
      data: {
        matchId: data.matchId,                              // 比赛ID（必填）
        matchScheduleModelId: data.matchScheduleModelId,    // 赛程模型ID（必填）
        name: data.name,                                    // 赛程名称（必填）
        startTime: data.startTime,                          // 赛程开始时间（时间戳，毫秒）
        endTime: data.endTime,                              // 赛程结束时间（时间戳，毫秒）
        regStartTime: data.regStartTime,                    // 报名开始时间（时间戳，毫秒）
        regEndTime: data.regEndTime,                        // 报名结束时间（时间戳，毫秒）
        status: data.status || 0                            // 赛程状态（整数，默认0-待发布）
      }
    })
  },

  // 编辑赛程
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/schedule/edit`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,              // 赛程ID（必填）
        matchId: data.matchId,                              // 比赛ID
        matchScheduleModelId: data.matchScheduleModelId,    // 赛程模型ID
        name: data.name,                                    // 赛程名称
        startTime: data.startTime,                          // 赛程开始时间
        endTime: data.endTime,                              // 赛程结束时间
        regStartTime: data.regStartTime,                    // 报名开始时间
        regEndTime: data.regEndTime,                        // 报名结束时间
        status: data.status                                 // 赛程状态
      }
    })
  },

  // 删除赛程
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/schedule/remove`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId               // 赛程ID（必填）
      }
    })
  },

  // 分页查询赛程
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/schedule/page`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,              // 赛程ID（可选，用于筛选）
        matchId: data.matchId,                              // 比赛ID（可选，用于筛选）
        matchScheduleModelId: data.matchScheduleModelId,    // 赛程模型ID（可选，用于筛选）
        name: data.name,                                    // 赛程名称（可选，用于模糊查询）
        startTime: data.startTime,                          // 赛程开始时间（可选，用于筛选）
        endTime: data.endTime,                              // 赛程结束时间（可选，用于筛选）
        regStartTime: data.regStartTime,                    // 报名开始时间（可选，用于筛选）
        regEndTime: data.regEndTime,                        // 报名结束时间（可选，用于筛选）
        status: data.status,                                // 赛程状态（可选，用于筛选）
        pageNum: data.pageNum || 0,                         // 页码（默认0）
        pageSize: data.pageSize || 20                       // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取赛程详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/schedule/get`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId               // 赛程ID
      }
    })
  }
}

/**
 * 赛程模型管理接口
 */
export const MatchScheduleModelAPI = {
  // 创建赛程模型
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModel/create`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID（可选）
        matchScheduleId: data.matchScheduleId,            // 赛程ID（可选）
        matchScheduleModelName: data.matchScheduleModelName, // 赛程模型名称（可选）
        roomNum: data.roomNum,                            // 房间数量（整数，0表示自动计算）
        roomType: data.roomType,                          // 房间类型（整数，0-5）
        roomTypeN: data.roomTypeN,                        // 房间类型N参数
        roomTypeM: data.roomTypeM,                        // 房间类型M参数
        roomStartType: data.roomStartType,                // 房间启动类型（整数，0-2）
        roomCreateModel: data.roomCreateModel,            // 房间创建模式（整数）
        roomJoinModel: data.roomJoinModel,                // 房间参与模式（整数，0-3）
        roomLimitModel: data.roomLimitModel,              // 房间限制模式（整数，0-2）
        matchModel: data.matchModel,                      // 比赛模式（整数）
        matchRegType: data.matchRegType,                  // 赛事报名模式（整数，0-3）
        matchWinModel: data.matchWinModel                 // 比赛获胜模式（整数，1-11）
      }
    })
  },

  // 编辑赛程模型
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModel/edit`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId,  // 赛程模型ID（必填）
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchScheduleId: data.matchScheduleId,            // 赛程ID
        matchScheduleModelName: data.matchScheduleModelName, // 赛程模型名称
        roomNum: data.roomNum,                            // 房间数量
        roomType: data.roomType,                          // 房间类型
        roomTypeN: data.roomTypeN,                        // 房间类型N参数
        roomTypeM: data.roomTypeM,                        // 房间类型M参数
        roomStartType: data.roomStartType,                // 房间启动类型
        roomCreateModel: data.roomCreateModel,            // 房间创建模式
        roomJoinModel: data.roomJoinModel,                // 房间参与模式
        roomLimitModel: data.roomLimitModel,              // 房间限制模式
        matchModel: data.matchModel,                      // 比赛模式
        matchRegType: data.matchRegType,                  // 赛事报名模式
        matchWinModel: data.matchWinModel                 // 比赛获胜模式
      }
    })
  },

  // 删除赛程模型
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModel/remove`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId   // 赛程模型ID（必填）
      }
    })
  },

  // 分页查询赛程模型
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModel/page`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID（可选）
        matchScheduleId: data.matchScheduleId,            // 赛程ID（可选）
        matchScheduleModelName: data.matchScheduleModelName, // 赛程模型名称（可选，用于筛选）
        roomNum: data.roomNum,                            // 房间数量（可选）
        roomType: data.roomType,                          // 房间类型（可选）
        roomTypeN: data.roomTypeN,                        // 房间类型N参数（可选）
        roomTypeM: data.roomTypeM,                        // 房间类型M参数（可选）
        roomStartType: data.roomStartType,                // 房间启动类型（可选）
        roomCreateModel: data.roomCreateModel,            // 房间创建模式（可选）
        roomJoinModel: data.roomJoinModel,                // 房间参与模式（可选）
        roomLimitModel: data.roomLimitModel,              // 房间限制模式（可选）
        matchModel: data.matchModel,                      // 比赛模式（可选）
        matchRegType: data.matchRegType,                  // 赛事报名模式（可选）
        matchWinModel: data.matchWinModel,                // 比赛获胜模式（可选）
        pageNum: data.pageNum || 0,                       // 页码（默认0）
        pageSize: data.pageSize || 20                     // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取赛程模型详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModel/get`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId   // 赛程模型ID
      }
    })
  }
}

/**
 * 房间模型管理接口
 */
export const MatchRoomModelAPI = {
  // 创建房间模型
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomModel/create`,
      method: 'POST',
      data: {
        matchRoomModelName: data.matchRoomModelName,        // 房间模型名称（可选）
        startPoint: data.startPoint,                        // 起点标识（字符串，必填）
        endPoint: data.endPoint,                            // 终点标识（字符串，必填）
        prepareTime: data.prepareTime,                      // 准备时间（毫秒，必填）
        limitTime: data.limitTime,                          // 限制时间（毫秒，必填）
        sort: data.sort || 1,                               // 排序（整数，用于规则排序）
        scoreModel: data.scoreModel,                        // 计分模式（整数，0-8）
        battleModel: data.battleModel                       // 对战模式（整数，0-2）
      }
    })
  },

  // 编辑房间模型
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomModel/edit`,
      method: 'POST',
      data: {
        matchRoomModelId: data.matchRoomModelId,            // 房间模型ID（必填）
        matchRoomModelName: data.matchRoomModelName,        // 房间模型名称
        startPoint: data.startPoint,                        // 起点标识
        endPoint: data.endPoint,                            // 终点标识
        prepareTime: data.prepareTime,                      // 准备时间
        limitTime: data.limitTime,                          // 限制时间
        sort: data.sort,                                    // 排序
        scoreModel: data.scoreModel,                        // 计分模式
        battleModel: data.battleModel                       // 对战模式
      }
    })
  },

  // 删除房间模型
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomModel/remove`,
      method: 'POST',
      data: {
        matchRoomModelId: data.matchRoomModelId             // 房间模型ID（必填）
      }
    })
  },

  // 分页查询房间模型
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomModel/page`,
      method: 'POST',
      data: {
        matchRoomModelName: data.matchRoomModelName,        // 房间模型名称（可选，用于筛选）
        startPoint: data.startPoint,                        // 起点标识（可选）
        endPoint: data.endPoint,                            // 终点标识（可选）
        prepareTime: data.prepareTime,                      // 准备时间（可选）
        limitTime: data.limitTime,                          // 限制时间（可选）
        sort: data.sort,                                    // 排序（可选）
        scoreModel: data.scoreModel,                        // 计分模式（可选）
        battleModel: data.battleModel,                      // 对战模式（可选）
        pageNum: data.pageNum || 0,                         // 页码（默认0）
        pageSize: data.pageSize || 20                       // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取房间模型详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomModel/get`,
      method: 'POST',
      data: {
        matchRoomModelId: data.matchRoomModelId             // 房间模型ID
      }
    })
  }
}

/**
 * 赛程模型引用管理接口
 */
export const MatchScheduleModelRefAPI = {
  // 创建赛程模型引用
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelRef/create`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId,  // 赛程模型ID（必填）
        matchRoomModelId: data.matchRoomModelId           // 房间模型ID（必填）
      }
    })
  },

  // 编辑赛程模型引用
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelRef/edit`,
      method: 'POST',
      data: {
        matchScheduleModelRefId: data.matchScheduleModelRefId,  // 赛程模型引用ID（必填）
        matchScheduleModelId: data.matchScheduleModelId,        // 赛程模型ID（可选）
        matchRoomModelId: data.matchRoomModelId                 // 房间模型ID（可选）
      }
    })
  },

  // 删除赛程模型引用
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelRef/remove`,
      method: 'POST',
      data: {
        matchScheduleModelRefId: data.matchScheduleModelRefId   // 赛程模型引用ID（必填）
      }
    })
  },

  // 分页查询赛程模型引用
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelRef/page`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId,        // 赛程模型ID（可选，用于筛选）
        matchRoomModelId: data.matchRoomModelId,                // 房间模型ID（可选，用于筛选）
        pageNum: data.pageNum || 0,                             // 页码（默认0）
        pageSize: data.pageSize || 20                           // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取赛程模型引用详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelRef/get`,
      method: 'POST',
      data: {
        matchScheduleModelRefId: data.matchScheduleModelRefId   // 赛程模型引用ID
      }
    })
  }
}

/**
 * 赛程结算管理接口
 */
export const MatchScheduleSettleAPI = {
  // 创建结算记录
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettle/create`,
      method: 'POST',
      data: {
        settleType: data.settleType,                    // 结算类型
        settleName: data.settleName,                    // 结算名称
        settleDesc: data.settleDesc                     // 结算描述
      }
    })
  },

  // 编辑结算记录
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettle/edit`,
      method: 'POST',
      data: {
        matchScheduleSettleId: data.matchScheduleSettleId,  // 结算记录ID（必填）
        settleType: data.settleType,                        // 结算类型
        settleName: data.settleName,                        // 结算名称
        settleDesc: data.settleDesc                         // 结算描述
      }
    })
  },

  // 删除结算记录
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettle/remove`,
      method: 'POST',
      data: {
        matchScheduleSettleId: data.matchScheduleSettleId   // 结算记录ID（必填）
      }
    })
  },

  // 分页查询结算记录
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettle/page`,
      method: 'POST',
      data: {
        settleType: data.settleType,                        // 结算类型（可选，用于筛选）
        settleName: data.settleName,                        // 结算名称（可选，用于筛选）
        settleDesc: data.settleDesc,                        // 结算描述（可选，用于筛选）
        pageNum: data.pageNum || 0,                         // 页码（默认0）
        pageSize: data.pageSize || 20                       // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取结算记录详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettle/get`,
      method: 'POST',
      data: {
        matchScheduleSettleId: data.matchScheduleSettleId   // 结算记录ID
      }
    })
  }
}

/**
 * 赛程结算关联管理接口
 */
export const MatchScheduleSettleRefAPI = {
  // 创建结算关联记录
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettleRef/create`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,              // 比赛日程ID
        matchScheduleSettleId: data.matchScheduleSettleId,  // 结算类型ID
        settleType: data.settleType                          // 结算类型代码
      }
    })
  },

  // 编辑结算关联记录
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettleRef/edit`,
      method: 'POST',
      data: {
        matchScheduleSettleRefId: data.matchScheduleSettleRefId,  // 关联记录ID（必填）
        matchScheduleId: data.matchScheduleId,                    // 比赛日程ID
        matchScheduleSettleId: data.matchScheduleSettleId,        // 结算类型ID
        settleType: data.settleType                               // 结算类型代码
      }
    })
  },

  // 删除结算关联记录
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettleRef/remove`,
      method: 'POST',
      data: {
        matchScheduleSettleRefId: data.matchScheduleSettleRefId   // 关联记录ID（必填）
      }
    })
  },

  // 分页查询结算关联记录
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettleRef/page`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,                    // 比赛日程ID（可选，用于筛选）
        matchScheduleSettleId: data.matchScheduleSettleId,        // 结算类型ID（可选，用于筛选）
        settleType: data.settleType,                              // 结算类型代码（可选，用于筛选）
        pageNum: data.pageNum || 0,                               // 页码（默认0）
        pageSize: data.pageSize || 20                             // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取结算关联记录详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleSettleRef/get`,
      method: 'POST',
      data: {
        matchScheduleSettleRefId: data.matchScheduleSettleRefId   // 关联记录ID
      }
    })
  }
}

/**
 * 房间规则管理接口
 */
export const MatchRoomRuleAPI = {
  // 创建房间规则
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomRule/create`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        startPoint: data.startPoint,                      // 起始点
        endPoint: data.endPoint,                          // 结束点
        prepareTime: data.prepareTime,                    // 准备时间（毫秒）
        limitTime: data.limitTime,                        // 限制时间（毫秒）
        round: data.round,                                // 回合数
        scoreModel: data.scoreModel,                      // 得分模式代码
        battleModel: data.battleModel,                    // 对战模式代码
        createTime: data.createTime || Date.now(),        // 创建时间
        updateTime: data.updateTime || Date.now()         // 更新时间
      }
    })
  },

  // 编辑房间规则
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomRule/edit`,
      method: 'POST',
      data: {
        matchRoomRuleId: data.matchRoomRuleId,            // 规则ID（必填）
        matchRoomId: data.matchRoomId,                    // 房间ID
        startPoint: data.startPoint,                      // 起始点
        endPoint: data.endPoint,                          // 结束点
        prepareTime: data.prepareTime,                    // 准备时间（毫秒）
        limitTime: data.limitTime,                        // 限制时间（毫秒）
        round: data.round,                                // 回合数
        scoreModel: data.scoreModel,                      // 得分模式代码
        battleModel: data.battleModel,                    // 对战模式代码
        updateTime: data.updateTime || Date.now()         // 更新时间
      }
    })
  },

  // 删除房间规则
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomRule/remove`,
      method: 'POST',
      data: {
        matchRoomRuleId: data.matchRoomRuleId             // 规则ID（必填）
      }
    })
  },

  // 分页查询房间规则
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomRule/page`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID（可选，用于筛选）
        startPoint: data.startPoint,                      // 起始点（可选）
        endPoint: data.endPoint,                          // 结束点（可选）
        round: data.round,                                // 回合数（可选）
        scoreModel: data.scoreModel,                      // 得分模式代码（可选）
        battleModel: data.battleModel,                    // 对战模式代码（可选）
        pageNum: data.pageNum || 0,                       // 页码（默认0）
        pageSize: data.pageSize || 20                     // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取房间规则详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomRule/get`,
      method: 'POST',
      data: {
        matchRoomRuleId: data.matchRoomRuleId             // 规则ID
      }
    })
  }
}

/**
 * 房间席位管理接口
 */
export const MatchRoomSeatAPI = {
  // 创建席位
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomSeat/create`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchRoomGroupId: data.matchRoomGroupId,          // 房间组ID
        matchScheduleRegId: data.matchScheduleRegId,      // 比赛日程注册ID
        signTime: data.signTime,                          // 签到时间戳
        owner: data.owner,                                // 席位所有者（用户ID）
        role: data.role,                                  // 角色权限代码
        status: data.status,                              // 席位状态代码
        event: data.event,                                // 席位事件代码
        createTime: data.createTime || Date.now(),        // 创建时间
        updateTime: data.updateTime || Date.now()         // 更新时间
      }
    })
  },

  // 编辑席位
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomSeat/edit`,
      method: 'POST',
      data: {
        matchRoomSeatId: data.matchRoomSeatId,            // 席位ID（必填）
        matchRoomId: data.matchRoomId,                    // 房间ID
        matchRoomGroupId: data.matchRoomGroupId,          // 房间组ID
        matchScheduleRegId: data.matchScheduleRegId,      // 比赛日程注册ID
        signTime: data.signTime,                          // 签到时间戳
        owner: data.owner,                                // 席位所有者（用户ID）
        role: data.role,                                  // 角色权限代码
        status: data.status,                              // 席位状态代码
        event: data.event,                                // 席位事件代码
        updateTime: data.updateTime || Date.now()         // 更新时间
      }
    })
  },

  // 删除席位
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomSeat/remove`,
      method: 'POST',
      data: {
        matchRoomSeatId: data.matchRoomSeatId             // 席位ID（必填）
      }
    })
  },

  // 分页查询席位
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomSeat/page`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID（可选，用于筛选）
        matchRoomGroupId: data.matchRoomGroupId,          // 房间组ID（可选）
        matchScheduleRegId: data.matchScheduleRegId,      // 比赛日程注册ID（可选）
        owner: data.owner,                                // 席位所有者（可选）
        role: data.role,                                  // 角色权限代码（可选）
        status: data.status,                              // 席位状态代码（可选）
        event: data.event,                                // 席位事件代码（可选）
        pageNum: data.pageNum || 0,                       // 页码（默认0）
        pageSize: data.pageSize || 20                     // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取席位详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomSeat/page`,
      method: 'POST',
      data: {
        matchRoomSeatId: data.matchRoomSeatId,         // 席位ID
        pageNum: data.pageNum || 0,                       // 页码（默认0）
        pageSize: data.pageSize || 1                     // 每页大小（默认20）
      }
    })
  }
}

/**
 * 赛程报名管理接口
 */
export const MatchScheduleRegAPI = {
  // 创建赛程报名
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleReg/create`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,            // 赛程ID（必填）
        userId: data.userId,                              // 用户ID（必填）
        pageSize: data.pageSize || 20,                    // 分页大小，默认20
        pageNum: data.pageNum || 0                        // 页码，默认0
      }
    })
  },

  // 修改赛程报名
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleReg/edit`,
      method: 'POST',
      data: {
        matchScheduleRegId: data.matchScheduleRegId,      // 报名记录ID（必填）
        matchScheduleId: data.matchScheduleId,            // 赛程ID（可选）
        pageSize: data.pageSize || 20,                    // 分页大小
        pageNum: data.pageNum || 0                        // 页码
      }
    })
  },

  // 删除赛程报名
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleReg/remove`,
      method: 'POST',
      data: {
        matchScheduleRegId: data.matchScheduleRegId       // 报名记录ID（必填）
      }
    })
  },

  // 分页查询赛程报名
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleReg/page`,
      method: 'POST',
      data: {
        matchScheduleId: data.matchScheduleId,            // 赛程ID（可选，查询条件）
        pageSize: data.pageSize || 20,                    // 分页大小，默认20
        pageNum: data.pageNum || 0                        // 页码，默认0
      }
    })
  }
}

/**
 * 房间成绩上报管理接口
 */
export const MatchRoomResultAPI = {
  // 创建比赛房间结果
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomResult/create`,
      method: 'POST',
      data: {
        appId: data.appId || 1,                           // 应用ID (必填)
        channel: data.channel || 1,                       // 渠道ID (必填)
        signature: data.signature,                        // 签名
        deviceId: data.deviceId,                          // 设备ID
        osVersion: data.osVersion,                        // 操作系统版本
        version: data.version,                            // 应用版本
        model: data.model,                                // 设备型号
        language: data.language,                          // 语言
        region: data.region,                              // 地区
        osType: data.osType,                              // 操作系统类型
        brand: data.brand,                                // 品牌
        timezone: data.timezone,                          // 时区
        clientTime: data.clientTime,                      // 客户端时间
        networkType: data.networkType,                    // 网络类型
        env: data.env,                                    // 环境
        registerTime: data.registerTime,                  // 注册时间
        packageName: data.packageName,                    // 包名
        matchRoomSeatId: data.matchRoomSeatId,            // 比赛房间座位ID
        matchRoomId: data.matchRoomId,                    // 比赛房间ID
        matchRoomRuleId: data.matchRoomRuleId,            // 比赛房间规则ID
        score: data.score,                                // 分数
        time: data.time,                                  // 完成时间 (毫秒)
        step: data.step,                                  // 步数
        cheatType: data.cheatType || 0,                   // 作弊类型
        matchPos: data.matchPos || 1                      // 比赛位置
      }
    })
  },

  // 编辑比赛房间结果
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomResult/edit`,
      method: 'POST',
      data: {
        appId: data.appId || 1,                           // 应用ID (必填)
        channel: data.channel || 1,                       // 渠道ID (必填)
        signature: data.signature,                        // 签名
        deviceId: data.deviceId,                          // 设备ID
        osVersion: data.osVersion,                        // 操作系统版本
        version: data.version,                            // 应用版本
        model: data.model,                                // 设备型号
        language: data.language,                          // 语言
        region: data.region,                              // 地区
        osType: data.osType,                              // 操作系统类型
        brand: data.brand,                                // 品牌
        timezone: data.timezone,                          // 时区
        clientTime: data.clientTime,                      // 客户端时间
        networkType: data.networkType,                    // 网络类型
        env: data.env,                                    // 环境
        registerTime: data.registerTime,                  // 注册时间
        packageName: data.packageName,                    // 包名
        matchRoomResultId: data.matchRoomResultId,        // 比赛房间结果ID (必填)
        matchRoomSeatId: data.matchRoomSeatId,            // 比赛房间座位ID
        matchRoomId: data.matchRoomId,                    // 比赛房间ID
        matchRoomRuleId: data.matchRoomRuleId,            // 比赛房间规则ID
        score: data.score,                                // 分数
        time: data.time,                                  // 完成时间 (毫秒)
        step: data.step,                                  // 步数
        cheatType: data.cheatType,                        // 作弊类型
        matchPos: data.matchPos                           // 比赛位置
      }
    })
  },

  // 删除比赛房间结果
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomResult/remove`,
      method: 'POST',
      data: {
        appId: data.appId || 1,                           // 应用ID (必填)
        channel: data.channel || 1,                       // 渠道ID (必填)
        signature: data.signature,                        // 签名
        deviceId: data.deviceId,                          // 设备ID
        osVersion: data.osVersion,                        // 操作系统版本
        version: data.version,                            // 应用版本
        model: data.model,                                // 设备型号
        language: data.language,                          // 语言
        region: data.region,                              // 地区
        osType: data.osType,                              // 操作系统类型
        brand: data.brand,                                // 品牌
        timezone: data.timezone,                          // 时区
        clientTime: data.clientTime,                      // 客户端时间
        networkType: data.networkType,                    // 网络类型
        env: data.env,                                    // 环境
        registerTime: data.registerTime,                  // 注册时间
        packageName: data.packageName,                    // 包名
        matchRoomResultId: data.matchRoomResultId         // 比赛房间结果ID (必填)
      }
    })
  },

  // 分页查询比赛房间结果
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomResult/page`,
      method: 'POST',
      data: {
        appId: data.appId || 1,                           // 应用ID (必填)
        channel: data.channel || 1,                       // 渠道ID (必填)
        signature: data.signature,                        // 签名
        deviceId: data.deviceId,                          // 设备ID
        osVersion: data.osVersion,                        // 操作系统版本
        version: data.version,                            // 应用版本
        model: data.model,                                // 设备型号
        language: data.language,                          // 语言
        region: data.region,                              // 地区
        osType: data.osType,                              // 操作系统类型
        brand: data.brand,                                // 品牌
        timezone: data.timezone,                          // 时区
        clientTime: data.clientTime,                      // 客户端时间
        networkType: data.networkType,                    // 网络类型
        env: data.env,                                    // 环境
        registerTime: data.registerTime,                  // 注册时间
        packageName: data.packageName,                    // 包名
        pageSize: data.pageSize || 20,                    // 分页大小 (默认20)
        pageNum: data.pageNum || 0,                       // 页码 (默认0)
        matchRoomResultId: data.matchRoomResultId,        // 比赛房间结果ID
        matchRoomSeatId: data.matchRoomSeatId,            // 比赛房间座位ID
        matchRoomId: data.matchRoomId,                    // 比赛房间ID
        matchRoomRuleId: data.matchRoomRuleId,            // 比赛房间规则ID
        score: data.score,                                // 分数
        time: data.time,                                  // 完成时间 (毫秒)
        step: data.step,                                  // 步数
        cheatType: data.cheatType,                        // 作弊类型
        matchPos: data.matchPos                           // 比赛位置
      }
    })
  }
}

/**
 * 房间分组管理接口
 */
export const MatchRoomGroupAPI = {
  // 创建房间分组
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomGroup/create`,
      method: 'POST',
      data: {
        matchRoomId: data.matchRoomId,                    // 房间ID（必填）
        name: data.name,                                  // 分组名称（必填）
        tag: data.tag,                                    // 分组标签（可选）
        pageSize: data.pageSize || 20,                    // 分页大小
        pageNum: data.pageNum || 0                        // 页码
      }
    })
  },

  // 编辑房间分组
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomGroup/edit`,
      method: 'POST',
      data: {
        matchRoomGroupId: data.matchRoomGroupId,          // 分组ID（必填）
        matchRoomId: data.matchRoomId,                    // 房间ID（可选）
        name: data.name,                                  // 分组名称（可选）
        tag: data.tag                                     // 分组标签（可选）
      }
    })
  },

  // 删除房间分组
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomGroup/remove`,
      method: 'POST',
      data: {
        matchRoomGroupId: data.matchRoomGroupId           // 分组ID（必填）
      }
    })
  },

  // 分页查询房间分组
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchRoomGroup/page`,
      method: 'POST',
      data: {
        matchRoomGroupId: data.matchRoomGroupId,          // 分组ID（可选，筛选条件）
        matchRoomId: data.matchRoomId,                    // 房间ID（可选，筛选条件）
        name: data.name,                                  // 分组名称（可选，筛选条件）
        tag: data.tag,                                    // 分组标签（可选，筛选条件）
        pageSize: data.pageSize || 20,                    // 分页大小，默认20
        pageNum: data.pageNum || 0                        // 页码，默认0
      }
    })
  }
}

/**
 * 赛程模式结算绑定管理接口
 */
export const MatchScheduleModelSettleRefAPI = {
  // 创建赛程模式结算绑定
  create: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelSettleRef/create`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId,        // 赛程模型ID
        matchScheduleSettleId: data.matchScheduleSettleId,      // 赛程结算规则ID
        settleType: data.settleType                             // 结算类型
      }
    })
  },

  // 编辑赛程模式结算绑定
  edit: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelSettleRef/edit`,
      method: 'POST',
      data: {
        matchScheduleModelSettleRefId: data.matchScheduleModelSettleRefId,  // 引用关系ID（必填）
        matchScheduleModelId: data.matchScheduleModelId,                    // 赛程模型ID
        matchScheduleSettleId: data.matchScheduleSettleId,                  // 赛程结算规则ID
        settleType: data.settleType                                         // 结算类型
      }
    })
  },

  // 删除赛程模式结算绑定
  remove: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelSettleRef/remove`,
      method: 'POST',
      data: {
        matchScheduleModelSettleRefId: data.matchScheduleModelSettleRefId   // 引用关系ID（必填）
      }
    })
  },

  // 分页查询赛程模式结算绑定
  page: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelSettleRef/page`,
      method: 'POST',
      data: {
        matchScheduleModelId: data.matchScheduleModelId,                    // 赛程模型ID（可选，用于筛选）
        matchScheduleSettleId: data.matchScheduleSettleId,                  // 赛程结算规则ID（可选，用于筛选）
        settleType: data.settleType,                                        // 结算类型（可选，用于筛选）
        pageNum: data.pageNum || 0,                                         // 页码（默认0）
        pageSize: data.pageSize || 20                                       // 每页大小（默认20）
      }
    })
  },

  // 根据ID获取赛程模式结算绑定详情
  getById: (data) => {
    return request({
      url: `${BATTLE_URL}/matchScheduleModelSettleRef/get`,
      method: 'POST',
      data: {
        matchScheduleModelSettleRefId: data.matchScheduleModelSettleRefId   // 引用关系ID
      }
    })
  }
}

/**
 * 接口使用示例
 */
export const BattleExamples = {
  // 创建竞技场示例
  createArenaExample: async () => {
    try {
      const result = await RankingAPI.createArena({
        arenaName: '魔方竞技场',
        regionType: '全国',
        arenaType: '公开'
      })
      return result
    } catch (error) {
      console.error('创建竞技场失败:', error)
      throw error
    }
  },

  // 加入房间示例
  joinRoomExample: async () => {
    try {
      const result = await BattleAPI.joinRoom({
        matchRoomId: 'room123',
        matchScheduleId: 'schedule123',
        name: '测试房间',
        matchTime: Date.now(),
        owner: 'user123',
        event: 1,
        status: 1,
        winModel: 1,
        startType: 1
      })
      return result
    } catch (error) {
      console.error('加入房间失败:', error)
      throw error
    }
  },

  // 生成打乱公式示例
  generateScrambleExample: async () => {
    try {
      const result = await BattleAPI.cubeGenerateScramble({})
      return result
    } catch (error) {
      console.error('生成打乱公式失败:', error)
      throw error
    }
  },

  // 获取排行榜示例
  getRankingListExample: async () => {
    try {
      const result = await RankingAPI.rankingList({
        session: 1,
        matchScheduleId: 'schedule123',
        pageNum: 0,
        pageSize: 10
      })
      return result
    } catch (error) {
      console.error('获取排行榜失败:', error)
      throw error
    }
  },

  // 创建比赛示例
  createMatchExample: async () => {
    try {
      const result = await MatchAPI.create({
        matchId: 'match_' + Date.now(),
        name: '魔方速拧比赛',
        startTime: Date.now(),
        endTime: Date.now() + 86400000,
        desc: '这是一场魔方速拧比赛',
        createUserID: 'user123',
        sponsor: '魔方协会',
        status: 1,
        matchModel: 1,
        matchModelId: 'model123'
      })
      return result
    } catch (error) {
      console.error('创建比赛失败:', error)
      throw error
    }
  },

  // 获取AI评审示例
  getAiReviewsExample: async () => {
    try {
      const result = await AiReviewAPI.getReviews({
        durationFrom: 60,
        durationTo: 120
      })
      return result
    } catch (error) {
      console.error('获取AI评审失败:', error)
      throw error
    }
  },

  // 创建房间示例
  createRoomExample: async () => {
    try {
      const result = await MatchRoomAPI.create({
        matchRoomId: 'room_' + Date.now(),
        matchScheduleId: 'schedule123',
        name: '对战房间',
        matchTime: Date.now(),
        owner: 'user123',
        event: 1,
        status: 1,
        winModel: 1,
        startType: 1
      })
      return result
    } catch (error) {
      console.error('创建房间失败:', error)
      throw error
    }
  },

  // 赛程报名示例
  regScheduleExample: async () => {
    try {
      const result = await BattleAPI.regSchedule({
        matchScheduleId: 'schedule123',                   // 要报名的赛程ID
        appId: 1,                                         // 应用ID
        channel: 1,                                       // 渠道ID
        pageSize: 20,                                     // 分页大小
        pageNum: 0                                        // 页码
      })
      return result
    } catch (error) {
      console.error('赛程报名失败:', error)
      throw error
    }
  }
}

// 导出所有API模块
export default {
  BattleAPI,
  RankingAPI,
  MatchAPI,
  AiReviewAPI,
  MatchRoomAPI,
  MatchModelAPI,
  MatchScheduleAPI,
  MatchScheduleModelAPI,
  MatchRoomModelAPI,
  MatchScheduleModelRefAPI,
  MatchScheduleSettleAPI,
  MatchScheduleSettleRefAPI,
  MatchRoomRuleAPI,
  MatchRoomSeatAPI,
  MatchScheduleRegAPI,
  MatchRoomResultAPI,
  MatchRoomGroupAPI,
  MatchScheduleModelSettleRefAPI,
  BattleExamples
} 